package com.star;

import com.star.test.CustomExceptions.ScoreException;
import com.star.test.Singleton;
import com.star.test.entity.*;
import com.star.test.port.Comparator;
import com.star.test.port.impl.ComparatorImpl;
import com.star.test.utils.JAVA35;
import com.star.test.utils.JAVA47;
import com.star.test.utils.JAVA48;
import com.star.test.utils.LikeRecorder;
import com.star.test.utils.impl.LikeRecorderImpl;

import java.sql.SQLOutput;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.util.*;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        //JAVA5(); //static,类名.方法或者方法可以直接调用，缺点不能直接访问非静态成员（如非 `static` 的变量或方法）,不能使用 `this` 或 `super` 关键字。
        //Main main = new Main();  //非static，需通过实例化对象调用
        //main.JAVA6();
        //JAVA7();
        //JAVA8();
        //JAVA9();
        //JAVA10();
        /*Scanner console = new Scanner(System.in);
        int m = console.nextInt();
        int n = console.nextInt();
        int result = JAVA11(m, n);
        System.out.println(result);*/
        //JAVA12();
        //JAVA13();
        //JAVA14();
        //JAVA15();
        //JAVA16();
        //JAVA17();
        //JAVA18();
        /*Main main = new Main();
        main.JAVA19();*/
        //JAVA20();
        //JAVA21();
        //JAVA22();
        //JAVA23();
        //JAVA24();
        //JAVA25();
        //JAVA26();
        //JAVA27();
        //JAVA28();
        //JAVA29();
        //JAVA30();
        //JAVA31();
        //JAVA32();
        //JAVA33();
        //JAVA34();
        //JAVA35();
        //JAVA36();
        //JAVA37();
        //JAVA38();
        //JAVA39();
        //JAVA40();
        //JAVA41();
        //JAVA42();
        //JAVA43();
        //JAVA44();
        //JAVA45();
        //JAVA46();
        //JAVA47();
        //JAVA48();
        //JAVA49();
        JAVA50();
    }

    /*牛客JAVA5
    牛牛商场促销活动：
    满100全额打9折；
    满500全额打8折；
    满2000全额打7折；
    满5000全额打6折；
    且商场有抹零活动，不足一元的部分不需要付款（类型强制转换）
    牛大姨算不清楚自己应该付多少钱，请你帮忙算一下*/
    private static void JAVA5() {
        Scanner console = new Scanner(System.in);
        int price = console.nextInt();
        int cost = 0;
        if (price >= 5000) {
            cost = (int) (price * 0.6);
        } else if (price >= 2000) {
            cost = (int) (price * 0.7);
        } else if (price >= 500) {
            cost = (int) (price * 0.8);
        } else if (price >= 100) {
            cost = (int) (price * 0.9);
        } else
            cost = (int) (price);
        System.out.println(cost);
    }

    /*体重指数 = 体重 (kg) / ( 身高 (m) × 身高 (m) )，
    小于18.5属于偏瘦，介于18.5和20.9之间（左闭右开）属于苗条，
    介于20.9和24.9之间（左闭右闭）属于适中，
    超过24.9属于偏胖。
    下面由你来编写一段逻辑，算出输入了身高和体重的用户的体重指数，并返回他们的身材状态。(体重指数请使用double类型)*/
    private void JAVA6() {
        Scanner scanner = new Scanner(System.in);
        double height = scanner.nextDouble();
        double weight = scanner.nextDouble();
        double index = weight / (height * height);
        if (index < 18.5) System.out.println("偏瘦");
        else if (index < 20.9) System.out.println("苗条");
        else if (index < 24.9) System.out.println("适中");
        else System.out.println("偏胖");
    }

    /*现有如下成绩等级A,B,C,D。其中
    A代表优秀，B代表良好，C代表及格，D代表不及格。
    现在请你来为学生的成绩进行分级，如果用户输入错误则输出未知等级。*/
    private static void JAVA7() {
        Scanner scanner = new Scanner(System.in);
        String grade = scanner.next();
        switch (grade) {
            case "A":
                System.out.println("优秀");
                break;
            case "B":
                System.out.println("良好");
                break;
            case "C":
                System.out.println("及格");
                break;
            case "D":
                System.out.println("不及格");
                break;
            default:
                System.out.println("未知等级");
                break;
        }

    }

    /*请根据给出的正则表达式来验证邮箱格式是否合法，
    如果用户输入的格式合法则输出「邮箱格式合法」，否则输出「邮箱格式不合法」。*/
    private static void JAVA8() {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        String emailMatcher = "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+";
        if (!str.isEmpty() && str.matches(emailMatcher)) {
            System.out.println("邮箱格式合法");
        } else
            System.out.println("邮箱格式不合法");
    }

    /*有数列为：9，99，999，...，9999999999。
    要求使用程序计算此数列的和，并在控制台输出结果。（请尝试使用循环的方式生成这个数列并同时在循环中求和）*/
    private static void JAVA9() {
        String base = "9";
        Long sum = 0L;
        String temp = "";
        for (int i = 0; i < 10; i++) {
            temp = temp + base;
            sum = sum + Long.parseLong(temp);
        }
        System.out.println(sum);
    }

    /*控制台输入整数，请设计一个死循环，
    当用户输入非正数时停止输入。请给出用户输入的正整数个数（默认输入个数不超过2147483647*/
    private static void JAVA10() {
        int count = 0;
        Scanner scanner = new Scanner(System.in);
        while (scanner.nextInt() > 0) count++;
        System.out.println(count);
    }

    /*编写一个方法，该方法的返回值是两个不大于100的正整数的最小公倍数*/
    private static int JAVA11(int a, int b) {
        int greatestCommonDivisor = gcd(a, b);
        int leastCommonMultiple = (a * b) / greatestCommonDivisor;
        return leastCommonMultiple;
    }

    private static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    /*一球从h米高度自由落下，每次落地后反弹回原高度的一半再落下，求它在第n次落地时共经过了多少米？第n次反弹多高？*/
    private static void JAVA12() {
        Scanner scanner = new Scanner(System.in);
        float h = scanner.nextFloat();
        int n = scanner.nextInt();
        float sum = 0;
        for (int i = 1; i <= n; i++) {
            if (i == 1) {
                sum = sum + h;
            } else
                sum = sum + h * 2;
            h = h / 2;
        }
        System.out.println(String.format("%.3f", h) + " " + String.format("%.3f", sum));
    }

    /*键盘输入任意多个10000以内正整数（负数代表结束），求出它们的平均数。*/
    private static void JAVA13() {
        Scanner scan = new Scanner(System.in);
        int count = 0, sum = 0, input = 0;
        double avg = 0;
        while ((input = scan.nextInt()) > 0) {
            sum = sum + input;
            count++;
            avg = (double) sum / count;
        }
        System.out.println(String.format("%.2f", avg));
    }

    /*判断质数*/
    private static void JAVA14() {
        Scanner scan = new Scanner(System.in);
        int number = scan.nextInt();
        System.out.println(isPrimeNumber(number));
    }

    private static Boolean isPrimeNumber(int number) {
        //2是质数
        //大于2的偶数不是质数
        //number有奇数因子（3，5，7...）不是质数
        if (number == 2) return true;
        if (number % 2 == 0) return false;
        for (int i = 3; i < number; i += 2) {
            if (number % i == 0) return false;
        }
        return true;
    }

    /*输入一个整数，计算它的位数。如果输入的整数不大于0则输出这个数*/
    private static void JAVA15() {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        scan.close();
        if (num <= 0) System.out.println(num);
        else {
            int digits = 0;
            String s = String.valueOf(num);
            digits = s.length();
            System.out.println(digits);
        }
    }

    /*将用户输入的六个数字填入数组并找出数组中最大值和最小值*/
    private static void JAVA16() {
        int[] ary = new int[6];
        int max;
        int min;
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < ary.length; i++) {
            ary[i] = scanner.nextInt();
        }
        max = ary[0];
        min = ary[0];
        for (int i = 0; i < ary.length; i++) {
            if (ary[i] > max) max = ary[i];
            if (ary[i] < min) min = ary[i];
        }
        System.out.println(max + " " + min);
    }

    /*输入6个整数，先将其输出然后再将数组倒转，再次输出数组*/
    private static void JAVA17() {
        int[] arr = new int[6];
        Scanner scanner = new Scanner(System.in);
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            //先保存值，再做交换
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }

    /*给定一个二维数组，请你编写一个求和函数，计算出这个数组元素的和*/
    private static void JAVA18() {
        int[][] arr = {{11, 33, 55}, {22, 44, 66, 88}, {131, 214, 315, 146}, {928, 827, 726, 625}, {424, 525}};
        int sum = add(arr);
        System.out.println(sum);
    }

    private static int add(int[][] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        return sum;
    }

    /*现有一个Data类，内部定义了属性x和y，
    在main方法中实例化了Data类，并计算了data对象中x和y的和。
    但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。*/
    private void JAVA19() {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            Data data = new Data(x, y);
            System.out.println(data.getX() + data.getY());
        }

    }

    class Data {

        private int x;
        private int y;

        private Data(int x, int y) {
            this.x = x;
            this.y = y;
        }

        private int getX() {
            return x;
        }

        private int getY() {
            return y;
        }
    }

    /*采用封装的思想，为Person类定义年龄属性，要求：
    修改年龄时判断其范围，若年龄小于0则按0输出，
    若年龄大于200则按200输出。*/
    private static void JAVA20() {
        Person p = new Person();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int age = scanner.nextInt();
            p.setAge(age);
            System.out.println(p.getAge());
        }
    }

    /*有父类Base，内部定义了x、y属性。有子类Sub，继承自父类Base。
    子类新增了一个z属性，并且定义了calculate方法，在此方法内计算了父类和子类中x、y、z属性三者的乘积。
    请补全子类构造方法的初始化逻辑，使得该计算逻辑能够正确执行。*/
    /*private static void JAVA21(){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            int z = scanner.nextInt();
            Sub sub = new Sub(x, y, z);
            System.out.println(sub.calculate());
        }
    }*/

    /*在父类Base中定义了计算方法calculate()，该方法用于计算两个数的乘积（X*Y）。
    请在子类Sub中重写该方法，将计算逻辑由乘法改为除法（X/Y）。
    注意，当分母为0时输出“Error”。*/
    /*private static void JAVA22() {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            Sub sub = new Sub(x, y);
            sub.calculate();
        }
    }*/

    /*已知有三个类：First、Second、Third。
    要求定义一个打印方法，支持传入任意引用类型的参数（包括上述三个类），并在方法内部打印出对象的字符串形式。*/
    private static void JAVA23() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String className = scanner.next();
            // print就是需要你定义的方法
            print(Class.forName(className).newInstance()); //使用反射动态创建以className命名的实例
        }
    }

    private static void print(Object o) {
        System.out.println(o);
    }

    /*父类Base有两个子类：Sub1、Sub2，现有一个方法getClassName()，
    要求传入Base类型的实例，在方法内部判定其具体的类型，
    返回的是类型的简单名字（不含包名），请补全getClassName()方法的判断逻辑。*/
    private static void JAVA24() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String className = scanner.next();
            Base obj = (Base) Class.forName(className).newInstance();
            System.out.println(getClassName(obj));
        }
    }

    public static String getClassName(Base obj) {
        return obj.getClass().getSimpleName();
    }

    /*已知抽象类Base中定义了calculate方法，该方法的计算过程依赖于sum()和avg()，
    而后两个方法均为抽象方法。要求定义Base的子类Sub类，
    并实现父类的抽象方法，使得main函数中的运算逻辑得以正确执行。*/
    /*private static void JAVA25(){
        // Sub是需要你定义的子类
        com.star.test.base.Base base = new com.star.test.base.Sub();

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            base.setX(x);
            base.setY(y);
            System.out.println(base.calculate());
        }
    }*/

    /*已知接口Comparator，内部定义了max函数，用于返回两个整数中的最大值。请定义该接口的实现类，
    使得main方法中的比较逻辑可以正确执行，要求实现类的名称为ComparatorImpl。*/
    private static void JAVA26() {
        Comparator comparator = new ComparatorImpl();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            System.out.println(comparator.max(x, y));
        }
    }

    /*父类Base中定义了若干get方法，以及一个sum方法，
    sum方法是对一组数字的求和。请在子类 Sub 中重写 getX() 方法，使得 sum 方法返回结果为 x*10+y*/
    private static void JAVA27() {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            Sub sub = new Sub(x, y);
            System.out.println(sub.sum());
        }
    }

    /*Singleton类是单例的，每次调用该类的getInstance()方法都将得到相同的实例，
    目前该类中这个方法尚未完成，请将其补充完整，使得main()函数中的判断返回真（不考虑线程安全）。*/
    private static void JAVA28() {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }

    /*将一个由英文字母组成的字符串转换成从末尾开始每三个字母用逗号分隔的形式。*/
    private static void JAVA29() {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        //StringBuilder result = new StringBuilder();
        ArrayList<String> result = new ArrayList<>();
        int len = str.length();
        for (int i = len; i > 0; i = i - 3) {
            int start = Math.max(0, i - 3);
            int end = i;
            result.add(str.substring(start, end));
        }
        Collections.reverse(result);//反转，将最后结果从前往后输出
        System.out.println(String.join(",", result));
    }

    /*给定一个字符串，随机输入一个字母，判断该字母在这个字符串中出现的次数*/
    private static void JAVA30() {
        String string = "H e l l o ! n o w c o d e r";
        Scanner scanner = new Scanner(System.in);
        String word = scanner.next();
        scanner.close();
        System.out.println(check(string, word));
    }

    private static int check(String str, String word) {
        HashMap<String, Integer> map = new HashMap<>();
        String[] split = str.split(" ");
        for (String s : split) {
            map.put(s, map.getOrDefault(s, 0) + 1);
        }
        return map.getOrDefault(word, 0);
    }

    /*控制台随机输入一个十进制数，请你将它转换为二进制数并输出*/
    private static void JAVA31() {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        if (num == 0) {
            System.out.println(0);
            return;//让程序立即退出当前方法，不再执行后续代码。
        }
        ArrayList<String> list = new ArrayList<>();
        while (num > 0) {
            int remainder = num % 2;
            list.add(String.valueOf(remainder));
            num = num / 2;
        }
        Collections.reverse(list);
        System.out.println(String.join("", list));//这种方式更加简洁美观
        System.out.println(list.toString().replaceAll("[\\[\\], ]", ""));
    }

    /*开发一个掷骰子游戏，即每次运行程序时，产生一个[1,6]之间的随机整数*/
    private static void JAVA32() {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int seed = scanner.nextInt();
            Random random = new Random(seed);
            int result = random.nextInt(6);
            System.out.println(result + 1);
        }
    }

    /*编写函数求出任意数的绝对值，平方根，对数，正弦值*/
    private static void JAVA33() {
        Scanner scanner = new Scanner(System.in);
        double num = scanner.nextDouble();
        System.out.println(Math.abs(num));
        System.out.println(Math.sqrt(num));
        System.out.println(Math.log(num));
        System.out.println(Math.sin(num));
    }

    /*输入任意年份，输出该年份各月天数（请使用 Calendar类(java8以前)中的方法）*/
    /*private static void JAVA34() {
        Scanner console = new Scanner(System.in);
        int year = console.nextInt();
        Calendar calendar = Calendar.getInstance();
        for (int month = 1; month <= 12; month++) {
            calendar.set(year, month - 1, 1);
            //获取当月最大天数
            int actualMaximum = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
            System.out.println(year + "年" + month + "月" + ":" +  actualMaximum + "天");
        }
    }*/

    /*输入任意年份，输出该年份各月天数（使用 Time类(java8以以后中的方法）*/
    private static void JAVA34() {
        Scanner console = new Scanner(System.in);
        int year = console.nextInt();
        for (int month = 1; month <= 12; month++) {
            //设置年份月份信息
            YearMonth yearMonth = YearMonth.of(year, month);
            //获取当月天数信息
            int actualMaximum = yearMonth.lengthOfMonth();
            System.out.println(year + "年" + month + "月" + ":" + actualMaximum + "天");

        }
    }

    /*已知，纽约时间比北京时间慢12小时，请根据用户输入的北京时间输出相应的纽约时间，
    若用户输入错误的月份或日期等信息则将其顺加。
    例如用户输入2021 13 32 14 43 54
    则生成北京时间为：2022-02-01 14:43:54 纽约时间为：2022-02-01 02:43:54*/
    private static void JAVA35() {
        Scanner in = new Scanner(System.in);
        String input = in.nextLine();
        String[] parts = input.split("\\s+");

        if (parts.length != 6) {
            System.out.println("您输入的数据不合理");
            return;
        }
        // 拼接成标准时间字符串
        String dateTimeStr = parts[0] + "-" + parts[1] + "-" + parts[2] + " " +
                parts[3] + ":" + parts[4] + ":" + parts[5];

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        sdf.setLenient(true); // 开启自动顺加（默认就是true）

        // 解析：自动处理 13月、32日 等非法输入
        Date beijingDate = null;
        try {
            beijingDate = sdf.parse(dateTimeStr);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
        System.out.println("北京时间为：" + sdf.format(beijingDate));

        // 转为 Calendar 减12小时
        Calendar cal = Calendar.getInstance();
        cal.setTime(beijingDate);
        cal.add(Calendar.HOUR_OF_DAY, -12);

        System.out.println("纽约时间为：" + sdf.format(cal.getTime()));

    }

    /*定义一个方法用于录入学生的考试成绩，要求考试成绩必须在0-100之间，不满足就产生一个自定义异常，
    控制台输出一个错误信息"分数不合法"（请输出自定义异常对象的错误信息，将错误信息设置为分数不合法）*/
    private static void JAVA36() {
        Scanner scanner = new Scanner(System.in);
        int score = scanner.nextInt();
        try {
            JAVA35.checkScores(score);
        } catch (ScoreException e) {
            System.out.println(e.getMessage());
        }
    }

    /*从键盘获取一串字符串，要求去除重复的字符。请使用HashSet解决这一问题*/
    private static void JAVA37() {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        scanner.close();
        HashSet<Character> hs = new HashSet<>();
        for (char c : str.toCharArray()) {
            hs.add(c);
        }
        for (Character c : hs) {
            System.out.print(c);
        }
    }

    /*请使用三种方式遍历一个list集合*/
    private static void JAVA38() {
        Scanner scanner = new Scanner(System.in);
        List<Integer> list = new ArrayList<>();
        int num1 = scanner.nextInt();
        int num2 = scanner.nextInt();
        int num3 = scanner.nextInt();
        int num4 = scanner.nextInt();
        int num5 = scanner.nextInt();
        scanner.close();
        list.add(num1);
        list.add(num2);
        list.add(num3);
        list.add(num4);
        list.add(num5);
        System.out.print("普通for循环:");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        //write your code here......


        System.out.println();
        System.out.print("增强for循环:");
        for (Integer integer : list) {
            System.out.print(integer + " ");
        }
        //write your code here......


        System.out.println();
        System.out.print("迭代器遍历:");
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            Integer num = it.next();
            System.out.print(num + " ");
        }
        System.out.println();
        System.out.print("函数式遍历:");
        //有多余的+ " "操作逻辑，所以不能使用方法引用System.out::println
        list.forEach(integer -> System.out.print(integer + " "));
        System.out.println();
    }

    /*请设计一个排队程序，用户有普通客人和 VIP客人之分，VIP客人不排队（即 VIP客人在队列头部），
    目前队列中已有两位客人小明和小军在排队，请将VIP客人小红新增至队列头部。*/
    private static void JAVA39() {
        Guest guest1 = new Guest("小明", false);
        Guest guest2 = new Guest("小军", false);
        Guest vipGuest = new Guest("小红", true);
        Deque<Guest> deque = new ArrayDeque<>();
        deque.add(guest1);
        deque.add(guest2);
        deque.addFirst(vipGuest);
        System.out.println(deque);
    }

    /*学生从一组学生中被挑选出来发表演讲。为了公平起见，头尾学生交替被选中。请通过程序实现离开队列的过程。*/
    private static void JAVA40() {
        // 使用泛型，类型安全
        ArrayDeque deque = new ArrayDeque<>();

        Scanner scanner = new Scanner(System.in);

        // 读取所有输入
        while (scanner.hasNext()) {
            String name = scanner.next();
            deque.offerLast(name);  // 从尾部加入，保持输入顺序
        }

        // 控制从头还是尾取人：true=头，false=尾
        boolean fromHead = true;

        // 交替出队
        while (!deque.isEmpty()) {
            if (fromHead) {
                System.out.println(deque.removeFirst());  // 从头部取
            } else {
                System.out.println(deque.removeLast());   // 从尾部取
            }
            // 切换方向
            fromHead = !fromHead;
        }

        scanner.close();
    }

    /*统计控制台输入的一句话中不同字⺟字符出现的次数。*/
    private static void JAVA41() {
        Scanner scanner = new Scanner(System.in);
        String line = scanner.nextLine();
        Map<Character, Integer> map = new LinkedHashMap<Character, Integer>();
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        Set<Map.Entry<Character, Integer>> entrys = map.entrySet();
        for (Map.Entry<Character, Integer> entry : entrys) {
            if (entry.getKey().charValue() >= 'A' && entry.getKey().charValue() <= 'Z' || entry.getKey().charValue() >= 'a' && entry.getKey().charValue() <= 'z') {
                System.out.println(entry.getKey() + ":" + entry.getValue());
            }

        }
    }

    /*现在有一个map集合如下：
    Map<Integer,String> map = new HashMap<Integer, String>();
    map.put(1, "Amy");
    map.put(2, "Joe");
    map.put(3, "Tom");
    map.put(4, "Susan");
    要求：
        1.遍历集合，并将序号与对应人名打印。
        2.向该map集合中插入一个编码为5姓名为控制台输入的人名的信息
        3.移除该map中的编号为4的信息
        4.将map集合中编号为3的姓名信息修改为"Tommy"
        5.再次遍历经过上述操作后的集合，并将序号与对应人名打印。(注：第一次输出和第二次输出需用空行隔开)*/
    private static void JAVA42() {
        Scanner scanner = new Scanner(System.in);
        String name = scanner.next();
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "Amy");
        map.put(2, "Joe");
        map.put(3, "Tom");
        map.put(4, "Susan");
        //1.遍历集合，并将序号与对应人名打印。
        for (Map.Entry<Integer, String> nameInfo : map.entrySet()) {
            System.out.println(nameInfo.getKey() + ":" + nameInfo.getValue());
        }
        //2.向该map集合中插入一个编码为5姓名为控制台输入的人名的信息
        map.put(5, name);
        //3.移除该map中的编号为4的信息
        map.remove(4);
        //4.将map集合中编号为3的姓名信息修改为"Tommy"
        map.replace(3, "Tommy");
        System.out.println();
        //5.再次遍历经过上述操作后的集合
        map.forEach((num, value) -> System.out.println(num + ":" + value));
    }

    /*有三个客户对象，将三个客户对象存入集合中，并将其按照消费总额从高到低排序*/
    private static void JAVA43() {
        Scanner scanner = new Scanner(System.in);
        Customer customer1 = new Customer("小明", scanner.nextInt());
        Customer customer2 = new Customer("小军", scanner.nextInt());
        Customer customer3 = new Customer("小红", scanner.nextInt());
        List<Customer> customers = new ArrayList<>();
        customers.add(customer1);
        customers.add(customer2);
        customers.add(customer3);
        Collections.sort(customers);
        Collections.reverse(customers);
        System.out.println(customers);
    }

    /*输出字符串中包含的英文字母个数，数字个数，空格个数，其它字符个数
    （格式为：英文字母x数字x空格x其他x），预设代码中已给出输出*/
    private static void JAVA44() {
        int numbers = 0;
        int words = 0;
        int space = 0;
        int other = 0;
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        int length = str.split(" ").length;
        space = length - 1;
        char[] charArray = str.toCharArray();
        for (char c : charArray) {
            if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') {
                words++;
            } else if (c >= 48 && c <= 57) {
                numbers++;
            } else {
                other++;
            }
        }
        other -= space;
        System.out.println("英文字母" + words + "数字" + numbers + "空格" + space + "其他" + other);
    }

    /*编写个人所得税计算程序*/
    private static void JAVA45() {
        List<Employee> employees = new ArrayList<>();
        Employee ming = new Employee("小明", 2500);
        Employee jun = new Employee("小军", 8000);
        Employee hong = new Employee("小红", 100000);
        employees.add(ming);
        employees.add(jun);
        employees.add(hong);
        for (Employee employee : employees) {
            double taxableIncome = employee.getSalary() - 3500;
            if (employee.getSalary() < 3500) {
                System.out.println(employee.getName() + "应该缴纳的个人所得税是：" + "0");
            }
            if (employee.getSalary() >= 3500 && taxableIncome <= 4500 && taxableIncome >= 1500) {
                double personalIncomeTax = taxableIncome * 0.1 - 105;
                System.out.printf("%s应该缴纳的个人所得税是: %.1f %n", employee.getName(), personalIncomeTax);
            }
            if (employee.getSalary() >= 3500 && taxableIncome > 80000) {
                double personalIncomeTax = taxableIncome * 0.45 - 13505;
                System.out.printf("%s应该缴纳的个人所得税是: %.1f %n", employee.getName(), personalIncomeTax);
            }
        }
    }

    /*为了实现社区点赞功能，要求设计一个点赞记录器，该工具包含如下两个方法：
    1. like方法：该方法需要传入用户名作为参数，如果用户没点赞过，则记录本次点赞行为，若用户已经点赞过，则删除他的点赞行为。
    2. getLikeUsers方法：该方法需要返回所有点赞用户的名字，不要求顺序。*/
    private static void JAVA46() {
        LikeRecorder recorder = new LikeRecorderImpl();

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String name = scanner.next();
            recorder.like(name);
        }

        System.out.println(Arrays.toString(recorder.getLikeUsers()));
    }

    /*判断回文数，若输入的五位数字是回文是则返回true，否则返回false。
    回文数即个位与万位相同，十位与千位相同的数字。如：12321、89898*/
    private static void JAVA47() {
        Scanner console = new Scanner(System.in);
        Main main = new Main();
        int number = console.nextInt();
        System.out.println(JAVA47.palindromeNumber(number));
    }

    /*输入两个正整数，输出这两个正整数之间有多少个大于2的素数。如果start>end，则将start设为end，end设为start*/
    private static void JAVA48() {
        Scanner scanner = new Scanner(System.in);
        int start = scanner.nextInt();
        int end = scanner.nextInt();
        JAVA48.method(start, end);
    }

    /*已知：
    1. 图形类Shape，该类中定义了图形的周长属性，以及返回周长的方法。
    2. Area接口，该接口中定义了返回面积的方法getArea()。
    要求：
    1. 定义圆形类Circle，使其继承于Shape，并实现Area接口。
    2. 定义方形类Square，使其继承于Shape，并实现Area接口。
    注意：
    圆周率要使用Math类中的常量。*/
    private static void JAVA49() {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextDouble()) {
            double s = scanner.nextDouble();
            // Circle和Square是需要你定义的类
            System.out.println(String.format("%.3f", new Circle(s).getArea()));
            System.out.println(String.format("%.3f", new Square(s).getArea()));
        }
    }

    /*有一个长度为7的无序数组，按照从小到大的顺序排序后输出。冒泡排序*/
    private static void JAVA50() {
        Scanner scanner = new Scanner(System.in);
        int[] arr = new int[7];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scanner.nextInt();
        }
        scanner.close();
        for (int j = 0; j < arr.length - 1; j++) { //总共需要比较arr.length - 1次即可
            for (int i = 1; i < arr.length - j; i++) { //第一轮循环结束之后，已经找到最大值，所有下一轮比较的时候不用比较最大值
                if (arr[i - 1] > arr[i]) {
                    int temp = arr[i - 1];
                    arr[i - 1] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        for (int k = 0; k < arr.length; k++) {
            System.out.print(arr[k] + " ");
        }
    }
}

